home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Presentations / Presentations ’97 / Sessions ’97 / Multiplatform Code⁄Data Sharing / HelloBothWorlds / GE / LibHdr / defs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-15  |  7.7 KB  |  232 lines  |  [TEXT/CWIE]
  1. /*
  2.     Defs.h
  3.     
  4.     Type definitions for Graphic Elements release version 1.0b1
  5.     
  6.     Updated 1/9/95 for Graphic Elements version 3.0
  7.     
  8.     Copyright 1994 by Al Evans. All rights reserved.
  9.     
  10.     
  11. */
  12.  
  13. #ifndef GEDEFS
  14. #define GEDEFS
  15.  
  16. #include "Preload.h"
  17. #include "List.h"
  18.  
  19. //All offscreen graphics are 8 bits deep
  20. #define    offscrnDepth    8
  21.  
  22. //Some forward declarations
  23. typedef struct GrafElement* GrafElPtr;
  24. typedef struct GEWorld* GEWorldPtr;
  25.  
  26. //Built-in directions
  27. typedef enum {none, up, left, down, right, upLeft, upRight, downLeft, downRight} GEDirection;
  28.  
  29. //Constant for "same-size" worlds
  30. #define scaleOneToOne 0x00010000
  31.  
  32. /* 
  33.     Prototype of function to initialize a graphic element from a resource or series
  34.     of resources. This function is responsible for creating an offscreen GWorld
  35.     for the element if required, and rendering the resource(s) into it.
  36.     
  37.     This function is responsible for setting the fields element->resID, element->graphRect,
  38.     and element->graphWorld.
  39. */
  40.  
  41. GE_CALLBACK_TDEF(Boolean,GraphicLoadFunc) (GEWorldPtr world, GrafElPtr element,
  42.                             short startResNum, short nResources);
  43.  
  44. /*
  45.     Prototype of function which, if present, will be called every time world is
  46.     updated, after drawing is complete. Can be used to automate other services
  47.     which need frequent time slices, such as sound maintenance procedures.
  48. */
  49.  
  50. GE_CALLBACK_TDEF(void, FramePostProcFunc) (GEWorldPtr world, Ptr data);
  51.  
  52. /*
  53.     Prototype for general-purpose bit copy function type-compatible
  54.     with CopyBits.  BitCopyProcs are normally used for
  55.     offscreen-to-offscreen copying only.  NOTE THAT THE PARAMETER
  56.     maskRgn IS ALMOST NEVER A MASK REGION! It is passed from the
  57.     drawData field of the graphic record.  It should normally be nil,
  58.     but can be used for data required by a specific custom bitcopying
  59.     procedure.
  60.     
  61.     If the "real" CopyBits is used directly for offscreen-to-offscreen
  62.     drawing, care must be taken that this field is nil or contains a
  63.     real region handle.
  64. */
  65.  
  66. GE_CALLBACK_TDEF(void,BitCopyProc) (const BitMap *srcBits, const BitMap *dstBits,
  67.                                const Rect   *srcRect, const Rect   *dstRect,
  68.                                short mode,  RgnHandle maskRgn);
  69.     
  70. /*
  71.     Prototype for autochange procedure, which periodically moves graphic,
  72.     changes frames, scrolls graphic, etc.
  73. */
  74.  
  75. GE_CALLBACK_TDEF(void,AutoChangeProc) (GEWorldPtr world, GrafElPtr element);
  76.  
  77. /*
  78.     Prototype for interact procedure, which handles collisions
  79. */
  80.  
  81. typedef enum {collisionBegin, collisionContinue, collisionEnd} CollisionPhase;
  82.  
  83. GE_CALLBACK_TDEF(void,CollisionProc)(GEWorldPtr world, GrafElPtr element, 
  84.                                 GEDirection dir,  CollisionPhase phase,
  85.                                 GrafElPtr hitElement);
  86.     
  87. /*
  88.     Prototype for rendering procedure to draw element
  89.     into offscreen "stage" world
  90. */
  91.  
  92. GE_CALLBACK_TDEF(void,RenderProc)(GrafElPtr element, GWorldPtr destGWorld);
  93.  
  94. /*
  95.     Prototype for sensor-tracking procedure, called when mouse
  96.     button is pressed in a graphic element with sensor properties
  97. */
  98.  
  99. GE_CALLBACK_TDEF(Boolean,SensorTrack)(GEWorldPtr world, GrafElPtr sensor);
  100.  
  101. /*
  102.     Prototype for action procedure to be called by sensor
  103. */
  104.  
  105. GE_CALLBACK_TDEF(void,SensorAction)(GEWorldPtr world, GrafElPtr sensor, short sensorState);
  106.  
  107. /*
  108.     Prototype for "custom" dispose procedure, called when Graphic Element is 
  109.     disposed to give element a chance to free up any memory it has allocated.
  110. */
  111.  
  112. GE_CALLBACK_TDEF(void,CleanupProc)(GEWorldPtr world, GrafElPtr element);
  113.  
  114. /*
  115.     Defined values for flags field of Graphic Element. Bits 5-13 are reserved
  116.     for future system use, bits 16-31 are available for use in defining
  117.     custom Graphic Elements.
  118. */
  119.  
  120. enum {    geShown =        0x00000001L,
  121.         geChanged =        0x00000002L,
  122.         geHit =            0x00000004L,
  123.         geSensor =        0x00000008L,
  124.         geForward =        0x00000010L,
  125.         geMirrored =    0x00004000L,
  126.         geInverted =    (short)0x8000
  127.     };
  128.     
  129. /*
  130.     The structure of an entry in a world's sensorList
  131. */
  132.  
  133. typedef struct SensorListEntry *SListEntryPtr;
  134.  
  135. typedef struct SensorListEntry {
  136.     SListEntryPtr    nextEntry;
  137.     Rect            sensorRect;
  138.     OSType            sensorID;
  139. } SensorListEntry;
  140.  
  141. /*
  142.     Forward declaration of a GE Timer record (see GETimer.h)
  143. */
  144.  
  145. typedef struct GETMgrRec *GETMgrRecPtr;
  146.     
  147. /*
  148.     A basic Graphic Element
  149. */
  150.  
  151. typedef struct GrafElement{
  152.  
  153.     //Bookkeeping and access
  154.     GrafElPtr        nextByPlane;        //Link in world's drawList
  155.     GrafElPtr        nextByID;            //Link in world's idList
  156.     GrafElPtr        masterGrafEl;        //Master (if any) controls movement of this GrafEl
  157.     GrafElPtr        slaveGrafEl;        //This GrafEl controls movement of slave (if any) 
  158.     OSType            objectID;            //This element's "name"
  159.     short            drawPlane;            //"Level" of object, higher number == closer to front
  160.     short            resID;                //# of resource from which element was derived, if any
  161.     long            flags;                //See definitions above
  162.     CleanupProc        cleanupProc;        //Custom dispose procedure, if any
  163.     
  164.     //Basic graphics data
  165.     GWorldPtr        graphWorld;            //Ptr to offscreen graphic, if any
  166.     Rect            graphRect;            //Source rectangle used by RenderProc
  167.     Rect            animationRect;        //Total dest rectangle, GEWorld coordinates
  168.     RenderProc        renderIt;            //Element's rendering procedure
  169.     BitCopyProc        drawIt;                //Lowlevel bit copier, if any
  170.     Ptr                drawData;            //Data passed to drawIt, if any
  171.     Rect            drawRect;            //Rect to update on this cycle
  172.     short            copyMode;            //Bit transfer mode
  173.  
  174.     //For automatic periodic changes
  175.     short            changeIntrvl;        //Interval between automatic changes
  176.     unsigned long    lastChangeTime;        //Last time autochange proc was called
  177.     AutoChangeProc    changeIt;            //Function for automatic changes
  178.     Ptr                changeData;            //Extra data for automatic changes
  179.     
  180.     //For collisions
  181.     CollisionProc    doCollision;        //Proc called when element collides
  182.     short            collisionPlane;        //Collides only with elements on this plane
  183.     GrafElPtr        collideElement;        //Other element involved in this collision
  184.     
  185.     //For direct user interactions
  186.     short            sensorType;            //Used to distinguish variant types
  187.     SensorTrack        trackingProc;        //Called when mousedown in sensor's rectangle
  188.     SensorAction    actionProc;            //Called by trackingProc when sensor is "activated"
  189.     short            sensorState;        //For whatever a sensor needs to save across calls
  190. } GrafElement;
  191.     
  192. /*
  193.     A world of Graphic Elements
  194. */
  195.  
  196. typedef struct GEWorld {
  197.  
  198.     GEWorldPtr         nextWorld;
  199.  
  200.     //Objects maintained by this world
  201.     GrafElPtr            drawList;        //Head of linked list of GrafElements in draw order
  202.     GrafElPtr            idList;            //Head of linked list of GrafElements by ID
  203.  
  204.     //Graphic environment of this world
  205.     GrafPtr                gEWPort;        //Onscreen GrafPort for this world
  206.     GDHandle            portGDevice;    //Device for this port
  207.     GWorldPtr            stageGWorld;    //Offscreen construction "stage" for this world
  208.     Rect                animationRect;    //Total dest rect of this world
  209.     CTabHandle            worldCTable;    //Offscreen color table, should == onscreen cTable
  210.     Point                worldFocus;        //Offset of world from window top left
  211.     Fixed                worldScale;        //Ratio of screen pixels to world pixels
  212.     
  213.     //Current state of this world
  214.     GraphicLoadFunc        defaultLoader;    //Loader used if no other is specified
  215.     FramePostProcFunc    postProcFunc;    //Called after every update
  216.     Ptr                    userData;        //Extra world data (passed to postProcFunc)
  217.     LHeaderPtr            activeRectList;    //Two lists of update rects, so that animation and
  218.     LHeaderPtr            safeRectList;    //screen updating can be concurrent
  219.     LHeaderPtr            sensorList;        //Sensors in this world, see Sensors.h
  220.     RgnHandle            clipRgn;        //Total clip region for this world
  221.     RgnHandle            otherWorldsCover; //in grafport coordinates
  222.     RgnHandle            userCovered;    //in grafport coordinates
  223.     GETMgrRecPtr        worldTime;        //Timer record for this world
  224.     unsigned long        lastFrameTime;    //last time screen was updated
  225.     short                msPerFrame;        //minimum "projection" interval, ms
  226.     Boolean                active;            //True if this animation is running
  227.     Boolean                changed;        //True if at least 1 object needs drawing
  228.     Boolean             onTop;          //True if topmost world    
  229. } GEWorld;
  230.  
  231. #endif
  232.